﻿using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Collections.Generic;
using Microsoft.SharePoint;
using System.Linq;
using System.Text;
using System.Collections;
using System.Data;

namespace TIT.ABDI.ChamadosTI.VWPRelatorioChamadoData
{
    public partial class VWPRelatorioChamadoDataUserControl : UserControl
    {
        SPWeb myWeb = SPContext.Current.Web;
        IFormatProvider culture = new System.Globalization.CultureInfo("pt-BR", true);

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                SetDdlTipoRelatorio();
                LimparRepeater();
            }
        }

        #region LimparRepeaters

        private void LimparCampos()
        {
            dtInicio.ClearSelection();
            dtFinal.ClearSelection();

            LimparRepeater();
        }
        private void LimparRepeater()
        {
            /*--Relatório Sintético Por Tipo*/
            rptRelatorioSinteticoTipo.DataSource = null;
            rptRelatorioSinteticoTipo.DataBind();
            /*------------------------------*/

            /*--Relatório Analítico--*/
            UPRelatorioAnalitico.Visible = false;
            LtvRelatorioAnalitico.DataSource = null;
            LtvRelatorioAnalitico.DataBind();

            lblRelatorioQtd.Text = null;
            lblRelatorioQtd.Visible = false;
            /*-----------------------*/

            /*--Relatório Sintético--*/
            UPRelatorioSintetico.Visible = false;
            LVTRelatorioSintetico.DataSource = null;
            LVTRelatorioSintetico.DataBind();

            lblRelatorioQtd.Text = null;
            lblRelatorioQtd.Visible = false;
            /*-----------------------*/
        }
        private List<Chamado> GetAllChamados()
        {
            List<Chamado> Chamado = myWeb.Lists["Chamado"].Items.Cast<SPListItem>()
                                    .Select(p => new Chamado()
                                    {
                                        Id = Convert.ToInt32(p["ID"]),
                                        Titulo = p["Título"].ToString(),
                                        Situacao = p["Situacao"].ToString().Split(new char[] {'#'},StringSplitOptions.RemoveEmptyEntries)[1],
                                        Criado = DateTime.Parse(p["Criado"].ToString()),
                                        CriadoPor = p["Criado por"].ToString(),
                                        Modificado = DateTime.Parse(p["Modificado"].ToString()),
                                        ModificadoPor = p["Modificado por"].ToString()
                                    }).ToList();

            return Chamado;
        }

        #endregion

        #region Métodos Privados

        private void RelatorioTotalChamadoPorPeriodo(DateTime dataInicial, DateTime dataFinal)
        {
            try
            {
                int _qtdAberto = GetAllChamados().Where(i => i.Criado.Date >= dataInicial.Date && i.Criado.Date <= dataFinal.Date).Count();
                int _qtdConcluido = GetAllChamados().Where(i => i.Modificado.Date >= dataInicial && i.Modificado.Date <= dataFinal && i.Situacao == "Concluído").Count();

                StringBuilder sb = new StringBuilder();

                sb.Append("<table class='chamadosRelatorio'>");
                sb.Append("<tr class='chamadoCabecalho'><td>Quantidade Aberto</td> <td>Quantidade Concluído</td></tr>");
                sb.Append("<tr class='ms-alternating'><td class='ms-vb'> " + _qtdAberto + " </td> <td class='ms-vb'> " + _qtdConcluido + " </td></tr>");
                sb.Append("</table>");

                lblRelatorioQtd.Text = sb.ToString();
                lblRelatorioQtd.DataBind();
                lblRelatorioQtd.Visible = true;
            }
            catch (Exception e)
            {
                Response.Write("Erro ao gerar relatório total. Erro: " + e.Message);
            }
        }
        private void SetDdlTipoRelatorio()
        {
            try
            {
                List<ListItem> TiposRelatorio = new List<ListItem>();

                TiposRelatorio.Add(new ListItem("Relatório Analítico", "1"));
                TiposRelatorio.Add(new ListItem("Relatório Sintético", "2"));
                TiposRelatorio.Add(new ListItem("Relatório Sintético - Tipo de Incidente", "3"));

                ddlTipoRelatorio.DataSource = TiposRelatorio;
                ddlTipoRelatorio.DataTextField = "text";
                ddlTipoRelatorio.DataValueField = "value";
                ddlTipoRelatorio.DataBind();
            }
            catch (Exception e)
            {
                Response.Write("Erro ao preencher o DropDownList. Erro: " + e.Message);
            }
        }

        #endregion

        #region Ações

        /*--Paginação--*/
        protected void LVTRelatorioSintetico_PreRender(object sender, EventArgs e)
        {
            try
            {
                RelatorioSinteticoPorPeriodo(dtInicio.SelectedDate, dtFinal.SelectedDate);
            }
            catch (Exception s)
            {
                Response.Write("Erro ao fazer paginação do Relatório Sintético. Erro: " + s.Message);
            }
        }
        protected void LtvRelatorioAnalitico_PreRender(object sender, EventArgs e)
        {
            try
            {
                SPList ListaChamado = myWeb.Lists["Chamado"];
                RelatorioAnaliticoPorPeriodo(ListaChamado, dtInicio.SelectedDate, dtFinal.SelectedDate);
            }
            catch (Exception s)
            {
                Response.Write("Erro ao fazer paginação do Relatório Analítico. Erro: " + s.Message);
            }
        }
        /*--Botões--*/
        /*--Consultar--*/
        protected void btnConsultar_Click(object sender, EventArgs e)
        {
            SPList getListChamado = myWeb.Lists["Chamado"];

            LimparRepeater();

            switch (Convert.ToInt32(ddlTipoRelatorio.SelectedValue))
            {
                case 1:
                    /*Analítico*/
                    UPRelatorioAnalitico.Visible = true;
                    RelatorioTotalChamadoPorPeriodo(dtInicio.SelectedDate, dtFinal.SelectedDate);
                    RelatorioAnaliticoPorPeriodo(getListChamado, dtInicio.SelectedDate, dtFinal.SelectedDate);
                    break;
                case 2:
                    /*Sintético*/
                    UPRelatorioSintetico.Visible = true;
                    RelatorioTotalChamadoPorPeriodo(dtInicio.SelectedDate, dtFinal.SelectedDate);
                    RelatorioSinteticoPorPeriodo(dtInicio.SelectedDate, dtFinal.SelectedDate);
                    break;
                case 3:
                    /*Sintético - Tipo de Incidente*/
                    RelatorioSinteticoPorPeriodoPorTipoIncidente(getListChamado, dtInicio.SelectedDate, dtFinal.SelectedDate);
                    break;
            }
        }
        /*--Limpar--*/
        protected void btnLimpar_Click(object sender, EventArgs e)
        {
            LimparCampos();
        }

        #endregion

        #region Relatórios Sintéticos

        private void RelatorioSinteticoPorPeriodo(DateTime dataInicial, DateTime dataFinal)
        {
            try
            {
                

                /*----------Recuperar todas as datas, agrupadas, do periodo selecionado----------*/
                var DataCriada = from u in GetAllChamados()
                                .Where(i => i.Criado.Date >= dataInicial.Date && i.Criado.Date <= dataFinal.Date)
                                .OrderBy(p => p.Criado.Date)
                            group u by u.Criado.Date into g
                            select new
                            {
                                Data = g.Key
                            };

                var DataModificada = from u in GetAllChamados()
                                         .Where(i => i.Modificado.Date >= dataInicial.Date && i.Modificado.Date <= dataFinal.Date)
                                         .OrderBy(p => p.Modificado.Date)
                                 group u by u.Modificado.Date into g
                                 select new
                                 {
                                     Data = g.Key
                                 };

                var ListaDataUnion = DataModificada.Union(DataCriada);

                /*-------------------------------------------------------------------------------*/

                /*--------Variaveis que serão usadas no StringBuilder---------*/
                DateTime dt = new DateTime();
                int SaldoAtual = 0;
                /*------------------------------------------------------------*/

                DataTable dataTable = new DataTable();
                dataTable.Columns.Add("Data", typeof(string));
                dataTable.Columns.Add("SaldoAnterior", typeof(int));
                dataTable.Columns.Add("Aberto", typeof(int));
                dataTable.Columns.Add("Concluido", typeof(int));
                dataTable.Columns.Add("SaldoAtual", typeof(int));
                dataTable.Columns.Add("Ver", typeof(string));

                /*---------------Recuperar Saldo Anterior----------------- */
                int QtdChamadoAberto = GetAllChamados().Where(i => i.Criado.Date < dataInicial.Date).Count();
                int QtdChamadoConcluido = GetAllChamados().Where(i => i.Situacao == "Concluído" && i.Modificado.Date < dataInicial.Date).Count();
                int SaldoAnterior = QtdChamadoAberto - QtdChamadoConcluido;
                /*---------------Recuperar Saldo Anterior----------------- */

                foreach (var data in ListaDataUnion.OrderBy(p => p.Data))
                {
                    dt = data.Data;

                    int QtdAberto = (from u in GetAllChamados()
                                    where u.Criado.Date == dt.Date
                                    select u).Count();

                    int QtdConcluido = (from u in GetAllChamados()
                                       where u.Modificado.Date == dt.Date && u.Situacao == "Concluído"
                                       select u).Count();

                    SaldoAtual = SaldoAnterior + QtdAberto - QtdConcluido;

                    string dataFormat = dt.ToShortDateString();

                    dataTable.Rows.Add(dataFormat,
                        SaldoAnterior,
                        QtdAberto,
                        QtdConcluido,
                        SaldoAtual,
                        String.Format("/SitePages/Adm/DetalheRelatorioSintetico.aspx?dtConsulta={0}", dataFormat)
                        );

                    SaldoAnterior = SaldoAtual;
                }

                LVTRelatorioSintetico.DataSource = dataTable;
                LVTRelatorioSintetico.DataBind();
            }
            catch (Exception e)
            {
                Response.Write("Erro ao gerar relatório sintético. Erro: " + e.Message);
            }
        }
        private void RelatorioSinteticoPorPeriodoPorTipoIncidente(SPList _getListChamado, DateTime dataInicial, DateTime dataFinal)
        {
            try
            {
                string DataInicial = dataInicial.ToShortDateString();
                string DataFinal = dataFinal.ToShortDateString();

                /*Recuperar Lista Chamado*/
                var ListaChamado = _getListChamado.Items.Cast<SPListItem>()
                    .Select(i => new
                    {
                        Titulo = i["Título"].ToString(),
                        Incidente = Convert.ToString(i["Incidente"]),
                        Status = i["Situacao"].ToString().Split(new char[] { '#' }, StringSplitOptions.RemoveEmptyEntries)[1],
                        DataModificado = DateTime.Parse(i["Modificado"].ToString().Substring(0, 10), culture)
                    })
                    .Where(i => i.Status == "Concluído" && i.DataModificado >= dataInicial && i.DataModificado <= dataFinal);
                /*-------------------------*/

                /*Recuperar Lista Incidente*/
                SPList getListIncidente = myWeb.Lists["Incidente"];
                var ListaIncidente = getListIncidente.Items.Cast<SPListItem>().Select(i => new { Incidente = i["Título"], Grupo = i["IdGrupo"].ToString() });
                /*-------------------------*/

                /*-- Realizar consulta, nas tabelas Chamados e(join) Incidente, agrupando por grupo de incidente --*/
                var ResultadoConsulta = from u in ListaChamado
                                        join j in ListaIncidente on u.Incidente.Substring(u.Incidente.IndexOf('#') + 1) equals j.Incidente.ToString() into NovaFonte
                                        from i in NovaFonte
                                        group i by i.Grupo into g
                                        select new
                                        {
                                            Grupo = g.Key.Substring(g.Key.IndexOf("#") + 1),
                                            Quantidade = g.Count(),
                                            Link = "?dtInicio=" + DataInicial + "&dtFinal=" + DataFinal + "&Incidente="
                                        };
                /*-------------------------------------------------------*/

                rptRelatorioSinteticoTipo.DataSource = ResultadoConsulta;
                this.DataBind();

                if (rptRelatorioSinteticoTipo.Items.Count == 0)
                {
                    Label lblControl = (Label)rptRelatorioSinteticoTipo.Controls[rptRelatorioSinteticoTipo.Controls.Count - 1].Controls[0].FindControl("lblEmptyData");
                    lblControl.Visible = true;
                }
            }
            catch (Exception e)
            {
                Response.Write("Erro ao gerar relatório sintético por tipo de incidente. Erro: " + e.Message);
            }
        }

        #endregion

        #region Relatórios Analíticos

        private void RelatorioAnaliticoPorPeriodo(SPList _getListChamado, DateTime dataInicial, DateTime dataFinal)
        {
            try
            {
                string DataInicial = dataInicial.ToShortDateString();
                string DataFinal = dataFinal.ToShortDateString();

                var ListaChamado = _getListChamado.Items.Cast<SPListItem>()
                    .Select(p => new
                    {
                        Titulo = p["Título"],
                        Prioridade = p["Prioridade"],
                        EnviadoPor = p["Criado por"],
                        Setor = p["AreaSolicitante"],
                        DataCriado = Convert.ToDateTime(p["Criado"]),
                        Status = p["Situacao"],
                        DataModificado = (p["Criado"].ToString() == p["Modificado"].ToString()) ? "Não Definido" : p["Modificado"].ToString(),
                        TipoIncidente = p["Incidente"],
                        Atendente = (p["Criado"].ToString() == p["Modificado"].ToString()) ? null : p["Modificado por"],
                        //Atendente = p["Modificado por"],
                        SetorTI = p["SetorTI"],
                        Requerimento = p["Requerimento"],
                       
                    })
                    .Where(i => Convert.ToDateTime(i.DataCriado.ToShortDateString()) >= dataInicial && Convert.ToDateTime(i.DataCriado.ToShortDateString()) <= dataFinal)
                    .OrderBy(i => i.DataCriado).ToList();

                LtvRelatorioAnalitico.DataSource = ListaChamado;
                LtvRelatorioAnalitico.DataBind();
            }
            catch (Exception e)
            {
                Response.Write("Erro ao gerar Relatório Analítico. Erro: " + e.Message);
            }
        }

        #endregion

    }
}
